home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 090 / cmln1285.arc / TWS.LST < prev    next >
File List  |  1986-02-27  |  20KB  |  602 lines
  1.  
  2. C:\TWS\TEST>pg prolog6
  3.  
  4. C:\TWS\TEST>echo off
  5. MetaWare TWS Skeleton.  30-Sep-85 19:29:03   prolog6.pg               Page 1
  6.  
  7. Scanner Grammar_lexicon(15-May-85 07:35:58)
  8. Parser  PSG_syntax(23-Feb-85 23:34:47)
  9. LINE # |----+----1----+----2----+----3----+----4----+----5----+----6----+----7-
  10.      1 |parser Start:
  11.      2 |
  12.      3 |Start      -> Prolog
  13.      4 |;
  14.      5 |Prolog     -> Prolog Clause
  15.      6 |           -> Clause
  16.      7 |;
  17.      8 |Clause     -> Goals '.'
  18.      9 |           -> Goals ':-' Goals '.'
  19.     10 |;
  20.     11 |Goals      -> Goals ',' Goal
  21.     12 |           -> Goal
  22.     13 |;
  23.     14 |Goal       -> Predicate '(' Components ')'
  24.     15 |;
  25.     16 |Components -> Components ',' Component
  26.     17 |           -> Component
  27.     18 |;
  28.     19 |Component  -> Functor '(' Components ')'
  29.     20 |           -> '<VARIABLE>'
  30.     21 |           -> Constant
  31.     22 |           -> List
  32.     23 |;
  33.     24 |Constant   -> '<NUMBER>'
  34.     25 |           -> '<ATOM>'
  35.     26 |;
  36.     27 |Functor    -> '<ATOM>'
  37.     28 |;
  38.     29 |Predicate  -> '<ATOM>'
  39.     30 |;
  40.     31 |List       -> '[' ']'
  41.     32 |           -> '[' Head ']'
  42.     33 |           -> '[' Head '|' Tail ']'
  43.     34 |;
  44.     35 |Head       -> Components
  45.     36 |;
  46.     37 |Tail       -> List
  47.     38 |;
  48.     39 |end Start
  49.     40 |do xref print_dpda
  50.     41 |
  51. No user errors    No warnings    286K of memory unused.
  52. End of processing, 30-Sep-85 19:29:07        prolog6.pg
  53. MetaWare LALR(1) Grammar Analyzer.  Today is 30-Sep-85 19:29:13
  54.  
  55. Removing the unit production for Predicate
  56. Removing the unit production for Functor
  57. Removing the unit production for Head
  58. Removing the unit production for Tail
  59. Back substituting all productions for Constant
  60.  
  61. -- Grammar flattened (regular expressions removed).
  62.  
  63. Grammar:  14 terminals, 9 nonterminals, and 18 productions.
  64.           42 is the total right part length.
  65. V O C A B U L A R Y   C R O S S - R E F E R E N C E
  66. ===================================================
  67.  
  68. '('                    8  11
  69. ')'                    8  11
  70. ','                    6  9
  71. '.'                    4  5
  72. ':-'                   5
  73. '<ATOM>'               8  11  13
  74. '<END_OF_FILE>'        0
  75. '<ILLEGAL_CHARACTER>'
  76. '<ILLEGAL_SYMBOL>'
  77. '<NUMBER>'             14
  78. '<VARIABLE>'           12
  79. '['                    16  17  18
  80. ']'                    16  17  18
  81. '|'                    18
  82. <system_goal_symbol>   0*
  83. Clause                 2  3  4* 5*
  84. Component              9  10  11* 12* 13* 14* 15*
  85. Components             8  9  11  17  18  9* 10*
  86. Goal                   6  7  8*
  87. Goals                  4  5  5  6  6* 7*
  88. List                   15  18  16* 17* 18*
  89. Prolog                 1  2  2* 3*
  90. Start                  0  1*
  91.  
  92. -- Grammar processing complete.
  93.  
  94. -- LR(0) parser:   36 states
  95.                    38    terminal transitions
  96.                    23 nonterminal transitions
  97.                    29 nuclei items
  98.  
  99. -- Look-ahead sets:
  100.          Relation     Examined/Edges    SCCs  Nodes
  101.          ------------------------------------------
  102.          Reads               0/   0        0      0
  103.          Follow              8/   8        0      0
  104.  
  105.        2 final items in 2 states needed SLR(1) look-ahead sets.
  106.        0 final items in 0 states needed LALR(1) look-ahead sets.
  107.        0 look-ahead sets were used in total.
  108.        8 set unions for computing  SLR(1) look-ahead sets.
  109.  
  110. -- The grammar is LALR(1); in fact, it is SLR(1).
  111.  
  112. DPDA:
  113.  
  114. State 19, accessed by
  115.     Terminal transitions               Nonterminal transitions
  116.        '<ATOM>' -> 23                     Start -> 20
  117.                                           Prolog -> 21
  118.                                           Clause -> 3
  119.                                           Goals -> 22
  120.                                           Goal -> 7
  121.  
  122. State 20, accessed by Start
  123.     Terminal transitions               Nonterminal transitions
  124.        '<END_OF_FILE>' -> 0
  125.  
  126. State 21, accessed by Prolog
  127.     Terminal transitions               Nonterminal transitions
  128.        '<ATOM>' -> 23                     Clause -> 2
  129.                                           Goals -> 22
  130.                                           Goal -> 7
  131.     Look-ahead transitions
  132.        { '<END_OF_FILE>' }  -> 1 Start -> Prolog
  133.  
  134. State 22, accessed by Goals
  135.     Terminal transitions               Nonterminal transitions
  136.        ':-' -> 24
  137.        ',' -> 25
  138.        '.' -> 4
  139.  
  140. State 23, accessed by '<ATOM>'
  141.     Terminal transitions               Nonterminal transitions
  142.        '(' -> 26
  143.  
  144. State 24, accessed by Goals ':-'
  145.     Terminal transitions               Nonterminal transitions
  146.        '<ATOM>' -> 23                     Goals -> 27
  147.                                           Goal -> 7
  148.  
  149. State 25, accessed by Goals ','
  150.     Terminal transitions               Nonterminal transitions
  151.        '<ATOM>' -> 23                     Goal -> 6
  152.  
  153. State 26, accessed by '<ATOM>' '('
  154.     Terminal transitions               Nonterminal transitions
  155.        '<ATOM>' -> 29                     Components -> 28
  156.        '<VARIABLE>' -> 12                 Component -> 10
  157.        '<NUMBER>' -> 14                   List -> 15
  158.        '[' -> 30
  159.  
  160. State 27, accessed by Goals ':-' Goals
  161.     Terminal transitions               Nonterminal transitions
  162.        ',' -> 25
  163.        '.' -> 5
  164.  
  165. State 28, accessed by '<ATOM>' '(' Components
  166.     Terminal transitions               Nonterminal transitions
  167.        ',' -> 31
  168.        ')' -> 8
  169.  
  170. State 29, accessed by '<ATOM>' '(' '<ATOM>'
  171.     Terminal transitions               Nonterminal transitions
  172.        '(' -> 32
  173.     Look-ahead transitions
  174.        { ')' ',' ']' '|' }  -> 13 Component ->
  175.            '<ATOM>'
  176.  
  177. State 30, accessed by '<ATOM>' '(' '['
  178.     Terminal transitions               Nonterminal transitions
  179.        ']' -> 16                          Components -> 33
  180.        '<ATOM>' -> 29                     Component -> 10
  181.        '<VARIABLE>' -> 12                 List -> 15
  182.        '<NUMBER>' -> 14
  183.        '[' -> 30
  184.  
  185. State 31, accessed by '<ATOM>' '(' Components ','
  186.     Terminal transitions               Nonterminal transitions
  187.        '<ATOM>' -> 29                     Component -> 9
  188.        '<VARIABLE>' -> 12                 List -> 15
  189.        '<NUMBER>' -> 14
  190.        '[' -> 30
  191.  
  192. State 32, accessed by '<ATOM>' '(' '<ATOM>' '('
  193.     Terminal transitions               Nonterminal transitions
  194.        '<ATOM>' -> 29                     Components -> 34
  195.        '<VARIABLE>' -> 12                 Component -> 10
  196.        '<NUMBER>' -> 14                   List -> 15
  197.        '[' -> 30
  198.  
  199. State 33, accessed by '<ATOM>' '(' '[' Components
  200.     Terminal transitions               Nonterminal transitions
  201.        ',' -> 31
  202.        '|' -> 35
  203.        ']' -> 17
  204.  
  205. State 34, accessed by '<ATOM>' '(' '<ATOM>' '(' Components
  206.     Terminal transitions               Nonterminal transitions
  207.        ',' -> 31
  208.        ')' -> 11
  209.  
  210. State 35, accessed by '<ATOM>' '(' '[' Components '|'
  211.     Terminal transitions               Nonterminal transitions
  212.        '[' -> 30                          List -> 36
  213.  
  214. State 36, accessed by '<ATOM>' '(' '[' Components '|' List
  215.     Terminal transitions               Nonterminal transitions
  216.        ']' -> 18
  217. -- Table packing:
  218.      0 multiply inconsistent states.
  219.     16 nonterminal transitions saved by default.
  220.     38 terminal entries in the comb.
  221.     29    teeth in terminal portion.
  222.     27    are non-empty.
  223.     16 nonterminal entries in the comb.
  224.     48    teeth in entire comb.
  225.     43    are non-empty.
  226.      5 of 9 SLR(1) look-ahead sets were distinct.
  227.  
  228.  
  229. Total (uncompressed) table size is
  230.     344 bytes of parse tables
  231. +   200 bytes of vocabulary
  232. +    84 bytes of error recovery info
  233. =   628 total.
  234. Parse tables written to disk.
  235.  
  236. No user errors.
  237. End of processing, 30-Sep-85 19:29:21
  238.  
  239. C:\TWS\TEST>sg prolog3
  240.  
  241. C:\TWS\TEST>echo off
  242. MetaWare TWS Skeleton.  30-Sep-85 18:56:29   prolog3.sg               Page 1
  243.  
  244. Scanner Grammar_lexicon(15-May-85 07:35:58)
  245. Parser  Lex_syntax(26-Jun-85 16:45:43)
  246. LINE # |----+----1----+----2----+----3----+----4----+----5----+----6----+----7-
  247.      1 |#-set lower_case
  248.      2 |
  249.      3 |scanner Prolog_text:
  250.      4 |
  251.      5 |Prolog_text -> (Pseudo | Separator)*;
  252.      6 |   Pseudo   -> Variable | String | Symbol | Number;
  253.      7 |   Separator-> Punctuator | Spaces | Eol;
  254.      8 |
  255.      9 |Variable    -> Varhead (Letter | Digit)*            => '<VARIABLE>';
  256.     10 |   Varhead  -> (Uppercase | Underscore);
  257.     11 |   Letter   -> Uppercase | Lowercase;
  258.     12 |   Uppercase-> 'A' .. 'Z';
  259.     13 |   Lowercase-> 'a' .. 'z';
  260.     14 |   Digit    -> '0' .. '9';
  261.     15 |   Underscore-> '_';
  262.     16 |
  263.     17 |String      -> (Quote Chars Quote)+                 => '<ATOM>';
  264.     18 |   Quote    -> '''';
  265.     19 |   Chars    -> (Any - Quote)*;
  266.     20 |
  267.     21 |Symbol      -> Lowercase (Letter | Digit)*          => '<ATOM>' ;
  268.     22 |
  269.     23 |Number      -> '-'? Digit+                          => '<NUMBER>';
  270.     24 |
  271.     25 |Punctuator  -> '(' | ')' | ',' | '[' | ']'
  272.     26 |               | '.' | '|' | ':' '-'                => '<AS_IS>';
  273.     27 |
  274.     28 |Spaces      -> Space+                               => '<DELETE>';
  275.     29 |Space       -> ' ' | Tab;
  276.     30 |   Tab      -> 'ht';
  277.     31 |
  278.     32 |
  279.     33 |end Prolog_text
  280.     34 |
  281. No user errors    No warnings    287K of memory unused.
  282. End of processing, 30-Sep-85 18:56:33        prolog3.sg
  283. MetaWare Scanner Generator.  Today is 30-Sep-85 18:56:39
  284.  
  285. -- Grammar constraints checked.
  286.  
  287.  
  288. -- FSM generated:       13 states.
  289.                        564 transitions.
  290.                          1 nuclei in largest nucleus bucket.
  291.                         12 items in all the nuclei.
  292.  
  293. -- Code generation:
  294.     150 entries in the comb.
  295.     130 teeth in the comb.
  296.      75 are non-empty.
  297.      74 words of s-code generated.
  298.  
  299. Total table size is
  300.     584 bytes of scan tables
  301. +   143 bytes of vocabulary/tracing info
  302. =   727 total.
  303. Scan tables written to disk.
  304. End of processing, 30-Sep-85 18:56:46
  305.  
  306. C:\TWS\TEST>pg psg2
  307.  
  308. C:\TWS\TEST>echo off
  309. MetaWare TWS Skeleton.  30-Sep-85 18:56:58   psg2.pg                  Page 1
  310.  
  311. Scanner Grammar_lexicon(15-May-85 07:35:58)
  312. Parser  PSG_syntax(23-Feb-85 23:34:47)
  313. LINE # |----+----1----+----2----+----3----+----4----+----5----+----6----+----7-
  314.      1 |parser PSG:
  315.      2 |
  316.      3 |PSG -> Program;
  317.      4 |Program -> ProgHead ProgParms ';' Pblk Pblock '.';
  318.      5 |
  319.      6 |ProgHead -> 'PROGRAM' '<IDENTIFIER>';
  320.      7 |ProgParms -> ;
  321.      8 |
  322.      9 |Pblock -> LBList TYPList VRList PList Pbegin StmtList 'END';
  323.     10 |Pbegin -> 'BEGIN';
  324.     11 |
  325.     12 |Block -> 'BEGIN' StmtList 'END';
  326.     13 |
  327.     14 |LBList -> 'LABEL' LabList ';'
  328.     15 |       -> ;
  329.     16 |LabList -> LabList ',' '<INTEGER>'
  330.     17 |        -> '<INTEGER>';
  331.     18 |
  332.     19 |VRList -> Var VList ';'
  333.     20 |       -> ;
  334.     21 |Var -> 'VAR';
  335.     22 |VList -> VList ';' VarItem
  336.     23 |      -> VarItem;
  337.     24 |VarItem -> IdentList ':' Type;
  338.     25 |IdentList -> IdentList ',' '<IDENTIFIER>'
  339.     26 |          -> '<IDENTIFIER>';
  340.     27 |
  341.     28 |TYPList -> 'TYPE' TList ';'
  342.     29 |        -> ;
  343.     30 |TList -> TList ';' TypItem
  344.     31 |      -> TypItem;
  345.     32 |TypItem -> '<IDENTIFIER>' '=' Type;
  346.     33 |
  347.     34 |Type -> SimpType
  348.     35 |     -> 'ARRAY' '[' Sint '..' Sint ']' 'OF' Type
  349.     36 |     -> 'RECORD' FieldList 'END';
  350.     37 |
  351.     38 |SimpType -> '<IDENTIFIER>';
  352.     39 |
  353.     40 |
  354.     41 |FieldList -> IdentList ':' Type
  355.     42 |          -> IdentList ':' Type ';' FieldList
  356.     43 |          -> 'CASE' SimpType 'OF' CaseList;
  357.     44 |
  358.     45 |
  359.     46 |CaseList -> CaseItem ';' CaseList
  360.     47 |         -> CaseItem;
  361.     48 |CaseItem -> ConstList ':' '(' FieldList ')';
  362.     49 |
  363.     50 |PList -> PList PFDecl
  364.     51 |      -> ;
  365.     52 |PFDecl -> ProcDecl
  366.     53 |       -> FuncDecl;
  367.     54 |ProcDecl -> ProcHead Parms ';' 'FORWARD' ';'
  368.     55 |         -> ProcHead Parms ';' Pblk Pblock ';';
  369. MetaWare TWS Skeleton.  30-Sep-85 18:56:58   psg2.pg                  Page 2
  370.  
  371. LINE # |----+----1----+----2----+----3----+----4----+----5----+----6----+----7-
  372.     56 |ProcHead -> 'PROCEDURE' '<IDENTIFIER>';
  373.     57 |FuncDecl -> FuncHead Parms ':' '<IDENTIFIER>' ';' 'FORWARD' ';'
  374.     58 |         -> FuncHead Parms ':' '<IDENTIFIER>' ';' Fblk Pblock ';';
  375.     59 |FuncHead -> 'FUNCTION' '<IDENTIFIER>';
  376.     60 |Parms ->
  377.     61 |         -> '(' ParmList ')';
  378.     62 |ParmList -> ParmList ';' Parm
  379.     63 |         -> Parm;
  380.     64 |Parm -> 'VAR' IdentList ':' SimpType
  381.     65 |     -> IdentList ':' SimpType;
  382.     66 |Pblk -> ;
  383.     67 |Fblk -> ;
  384.     68 |
  385.     69 |StmtList -> StmtList ';' Stmt
  386.     70 |         -> Stmt;
  387.     71 |Stmt -> 'IF' Boolean Then Stmt
  388.     72 |     -> 'IF' Boolean Then Stmt Else Stmt
  389.     73 |     -> 'WHILE' Boolean Do Stmt
  390.     74 |     -> Repeat StmtList 'UNTIL' Boolean
  391.     75 |     -> 'FOR' VarHead ':=' Boolean 'TO' Boolean Fup Stmt
  392.     76 |     -> 'FOR' VarHead ':=' Boolean 'DOWNTO' Boolean Fdown Stmt
  393.     77 |     -> Variable ':=' Boolean
  394.     78 |     -> ProcCall
  395.     79 |     -> '<IDENTIFIER>'
  396.     80 |     -> 'GOTO' '<INTEGER>'
  397.     81 |     -> Label ':' Stmt
  398.     82 |     -> Block
  399.     83 |     -> ReadWrite '(' IOList ')'
  400.     84 |     -> ;
  401.     85 |Then -> 'THEN';
  402.     86 |Else -> 'ELSE';
  403.     87 |Fup -> 'DO';
  404.     88 |Fdown -> 'DO';
  405.     89 |Do -> 'DO';
  406.     90 |Repeat -> 'REPEAT';
  407.     91 |Label -> '<INTEGER>';
  408.     92 |ReadWrite -> 'READ'
  409.     93 |          -> 'WRITE';
  410.     94 |
  411.     95 |IOList -> IOList ',' IOItem
  412.     96 |       -> IOItem;
  413.     97 |IOItem -> Boolean
  414.     98 |       -> '<string>';
  415.     99 |
  416.    100 |ProcCall -> '<IDENTIFIER>' '(' BoolList ')';
  417.    101 |BoolList -> BoolList ',' Boolean
  418.    102 |         -> Boolean;
  419.    103 |
  420.    104 |Boolean -> BoolTerm
  421.    105 |        -> Boolean 'OR' BoolTerm;
  422.    106 |BoolTerm -> BoolUnary
  423.    107 |         -> BoolTerm 'AND' BoolUnary;
  424.    108 |BoolUnary -> BoolPri
  425.    109 |          -> 'NOT' BoolPri;
  426.    110 |BoolPri -> Expr
  427.    111 |        -> Expr Relop Expr;
  428.    112 |
  429. MetaWare TWS Skeleton.  30-Sep-85 18:56:58   psg2.pg                  Page 3
  430.  
  431. LINE # |----+----1----+----2----+----3----+----4----+----5----+----6----+----7-
  432.    113 |Relop -> '<'
  433.    114 |      -> '>'
  434.    115 |      -> '<='
  435.    116 |      -> '>='
  436.    117 |      -> '='
  437.    118 |      -> '<>';
  438.    119 |
  439.    120 |Expr -> Expr '+' Term
  440.    121 |     -> Expr '-' Term
  441.    122 |     -> Term;
  442.    123 |Term -> Term '*' Unary
  443.    124 |     -> Term '/' Unary
  444.    125 |     -> Term 'MOD' Unary
  445.    126 |     -> Term 'DIV' Unary
  446.    127 |     -> Unary;
  447.    128 |Unary -> Primary
  448.    129 |      -> '-' Primary;
  449.    130 |Primary -> '(' Boolean ')'
  450.    131 |        -> ProcCall
  451.    132 |        -> Variable
  452.    133 |        -> Constant;
  453.    134 |
  454.    135 |Variable -> VarHead VarExtension;
  455.    136 |VarHead -> '<IDENTIFIER>';
  456.    137 |VarExtension -> VarExtension VarExt
  457.    138 |             -> ;
  458.    139 |VarExt -> '[' BoolList ']'
  459.    140 |       -> '.' '<IDENTIFIER>';
  460.    141 |
  461.    142 |Constant -> '<REAL>'
  462.    143 |         -> '<INTEGER>'
  463.    144 |         -> 'TRUE'
  464.    145 |         -> 'FALSE';
  465.    146 |ConstList -> ConstList ',' Constant
  466.    147 |          -> Constant;
  467.    148 |Sint -> '<INTEGER>'
  468.    149 |     -> '-' '<INTEGER>';
  469.    150 |end PSG
  470. No user errors    No warnings    286K of memory unused.
  471. End of processing, 30-Sep-85 18:57:07        psg2.pg
  472. MetaWare LALR(1) Grammar Analyzer.  Today is 30-Sep-85 18:57:12
  473.  
  474. Removing the unit production for Pbegin
  475. Removing the unit production for Var
  476. Removing the unit production for SimpType
  477. Removing the unit production for Then
  478. Removing the unit production for Else
  479. Removing the unit production for Do
  480. Removing the unit production for Repeat
  481. Removing the unit production for VarHead
  482. Removing the unit production for Fup
  483. Removing the unit production for Fdown
  484. Removing the unit production for Label
  485. Back substituting all productions for Program
  486. Back substituting all productions for ProgHead
  487. Back substituting all productions for ProgParms
  488. Back substituting all productions for Block
  489. Back substituting all productions for PFDecl
  490. Back substituting all productions for ProcDecl
  491. Back substituting all productions for FuncDecl
  492. Back substituting all productions for Fblk
  493. Back substituting all productions for VarExt
  494.  
  495. -- Grammar flattened (regular expressions removed).
  496.  
  497. Grammar:  60 terminals, 44 nonterminals, and 106 productions.
  498.           267 is the total right part length.
  499.  
  500. -- Grammar processing complete.
  501.  
  502. -- LR(0) parser:  247 states
  503.                   454    terminal transitions
  504.                   316 nonterminal transitions
  505.                   217 nuclei items
  506.  
  507. -- Look-ahead sets:
  508.          Relation     Examined/Edges    SCCs  Nodes
  509.          ------------------------------------------
  510.          Reads               9/   9        0      0
  511.          Follow             45/  45        0      0
  512.          Includes           76/ 549        1      6
  513.          Lookback           21/ 560
  514.  
  515.       38 final items in 38 states needed SLR(1) look-ahead sets.
  516.        3 final items in 2 states needed LALR(1) look-ahead sets.
  517.       39 look-ahead sets were used in total.
  518.       45 set unions for computing  SLR(1) look-ahead sets.
  519.      111 set unions for computing LALR(1) look-ahead sets.
  520.      156 set unions total.
  521. E :     The grammar is NOT LALR(1).  Here are the conflicts:
  522.  
  523. AFTER:  'PROGRAM' '<IDENTIFIER>' ';' Pblk LBList TYPList VRList  ...
  524. ... PList 'BEGIN' 'IF' Boolean 'THEN' '<INTEGER>' ':' 'IF' Boolean  ...
  525. ... 'THEN' Stmt                                            state  217:
  526. Read?   'ELSE'
  527. Reduce? 44 Stmt -> 'IF' Boolean 'THEN' Stmt
  528.         { 'ELSE' }
  529.  
  530. -- LALR(1) look-ahead conflict summary:
  531.      1 read  /reduce conflicts in 1 states.
  532.      0 reduce/reduce conflicts in 0 states.
  533.      1 states  with  conflicts.
  534.  
  535.  
  536. >>>     Here are some traces for offending symbols in      state  217 <<<<<<<<
  537.  
  538. PSG '<END_OF_FILE>'
  539. 'PROGRAM' '<IDENTIFIER>' ';' Pblk Pblock '.'
  540.                                   LBList TYPList VRList PList  ...
  541. ... 'BEGIN' StmtList 'END'
  542.             Stmt
  543.             'IF' Boolean 'THEN' Stmt 'ELSE' Stmt
  544.                                 |
  545.                                 '<INTEGER>' ':' Stmt
  546.                                                 'IF' Boolean  ...
  547. ... 'THEN' Stmt
  548.      ????? Reduce? 44 Stmt -> 'IF' Boolean 'THEN' Stmt
  549.  
  550. PSG '<END_OF_FILE>'
  551. 'PROGRAM' '<IDENTIFIER>' ';' Pblk Pblock '.'
  552.                                   LBList TYPList VRList PList  ...
  553. ... 'BEGIN' StmtList 'END'
  554.             Stmt
  555.             'IF' Boolean 'THEN' Stmt
  556.                                 '<INTEGER>' ':' Stmt
  557.                                                 'IF' Boolean  ...
  558. ... 'THEN' Stmt . 'ELSE' Stmt
  559.      ????? Read? 'ELSE'
  560.  
  561. >>>     Here are the states with conflicts:
  562.  
  563. State 217, accessed by 'PROGRAM' '<IDENTIFIER>' ';' Pblk LBList  ...
  564. ... TYPList VRList PList 'BEGIN' 'IF' Boolean 'THEN' Stmt
  565.     Terminal transitions               Nonterminal transitions
  566.        'ELSE' -> 233
  567.     Look-ahead transitions
  568.        { ';' 'ELSE' 'END' 'UNTIL' }  -> 44 Stmt -> 'IF' Boolean 'THEN'
  569.            Stmt
  570. The item set for this state is:
  571.          44 Stmt  -> 'IF' Boolean 'THEN' Stmt .
  572.   233 |  45 Stmt  -> 'IF' Boolean 'THEN' Stmt . 'ELSE' Stmt
  573.  
  574. >>> End of debugging information for LALR(1) look-ahead  problems.
  575.  
  576. -- The grammar is NOT LALR(1) <<<<<<<<<<<<<<<<<<<<
  577.  
  578. -- Table packing:
  579.      1 multiply inconsistent states.
  580.      3 entries in the exception list.
  581.    241 nonterminal transitions saved by default.
  582.    454 terminal entries in the comb.
  583.    170    teeth in terminal portion.
  584.    166    are non-empty.
  585.    119 nonterminal entries in the comb.
  586.    319    teeth in entire comb.
  587.    285    are non-empty.
  588.     30 of 44 SLR(1) look-ahead sets were distinct.
  589.  
  590.  
  591. Total (uncompressed) table size is
  592.    2238 bytes of parse tables
  593. +   768 bytes of vocabulary
  594. +   696 bytes of error recovery info
  595. =  3702 total.
  596. Parse tables written to disk.
  597.  
  598. 1 user errors.
  599. End of processing, 30-Sep-85 18:57:26
  600.  
  601. C:\TWS\TEST>
  602.